// app 页面接口
const express = require("express");
const writeData = require("../../db/module/writeData");
const readData = require("../../db/module/readData");
const delData = require("../../db/module/delData");
const apiRouter = express.Router();

// 添加or修改菜单
apiRouter.post("/addMenu", async (req, res) => {
    try {
        const params = req.body;

        // 写入数据格式 限制
        // {
        //     "name":"ceshi",
        //     "componentPath":"ceshi1",
        //     "meta":{
        //         "title":"测试菜单",
        //         "icon":"tab"
        //     },
        //     "path":"/home",
        //     "isOpen":false,
        //     "parentId":"1084c0a4-8efe-4e7c-88b9-c17015d44973"
        // }

        let result = await writeData(params, "menu");

        res.send(result);
    } catch (error) {
        res.send({
            code: 50000,
            msg: error,
        });
    }
});

// 查询菜单
apiRouter.post("/queryMenu", async (req, res) => {
    try {
        const params = req.body;

        let result = await readData(params, "menu");

        function buildTree(data) {
            const nodeMap = new Map();
            const tree = [];

            // 第一次遍历：将所有节点存入映射表
            data.forEach(item => {
                const node = { ...item, children: [] };
                nodeMap.set(node.id, node);
            });

            // 第二次遍历：构建树形结构
            data.forEach(item => {
                const node = nodeMap.get(item.id);
                let parentId = item.parentId;

                // 如果没有parentId，或者父节点不存在且父ID等于自身ID，作为根节点
                if (!parentId || (parentId === node.id && !nodeMap.has(parentId))) {
                    tree.push(node);
                    return;
                }

                // 查找父节点
                let parentNode = nodeMap.get(parentId);

                // 如果找不到父节点，将自身作为父节点（但不添加到children）
                if (!parentNode) {
                    tree.push(node);
                } else {
                    // 防止循环引用：确保父节点不是当前节点的子节点
                    if (!hasChild(node, parentNode.id)) {
                        parentNode.children.push(node);
                    } else {
                        // 如果存在循环风险，将当前节点作为根节点
                        tree.push(node);
                    }
                }
            });

            // 辅助函数：检查节点是否有特定子节点（递归）
            function hasChild(node, childId) {
                if (node.id === childId) return true;
                return node.children.some(child => hasChild(child, childId));
            }

            return tree;
        }

        let newThere = buildTree(result.data)


        res.send({
            code: 20000,
            msg: "查询成功",
            data: newThere
        });
    } catch (error) {
        res.send({
            code: 50000,
            msg: error.message,
        });
    }
});

// 删除菜单
apiRouter.post("/deleteMenu", async (req, res) => {
    try {
        const params = req.body;


        async function queryAllChildren(id) {
            // 获取当前节点的直接子节点
            let { data: dataList } = await readData({ parentId: id }, "menu");

            // 初始化结果数组，包含当前节点ID
            let allChildrenId = [id];

            // 等待所有子节点的递归结果
            await Promise.all(dataList.map(async item => {
                // 递归获取子节点的所有后代ID
                const childrenIds = await queryAllChildren(item.id);

                // 将递归结果合并到总结果中
                allChildrenId = allChildrenId.concat(childrenIds);
            }));

            return allChildrenId;
        }

        let delIdList = await queryAllChildren(params.id)


        // 删除筛选出来的数据
        await delData(delIdList, "menu");

        res.send({
            code: 20000,
            msg: "删除成功",
        });

    } catch (error) {
        res.send({
            code: 50000,
            msg: error.message,
        });
    }
});

module.exports = apiRouter;
